#ifndef VECTOR_H
#define VECTOR_H

#include <algorithm>

/**
 * @brief 创建类模板 Vector
 * 
 * @tparam Object
 */
template <typename Object>
class Vector
{   
    /**
    * @brief 私有成员
    * 
    * @tparam 
    */
    private:
        
        int theSize;
        int theCapacity;
        Object * objects;

    /**
    * @brief 公有成员
    * 
    */
    public:
    
        /**
        * @brief 初始的备用存储空间
        * 
        */
        static const int SPARE_CAPACITY = 16;

        /**
        * @brief 构造函数，同时用于初始化生成一个Vector
        * 
        */
        explicit Vector(int initSize = 0): theSize{initSize},
            theCapacity{initSize + SPARE_CAPACITY}
            {objects = new Object[theCapacity];}

        /**
        * @brief 构造函数，同时拷贝一个现有的成员生成一个Vector
        * 
        * @param rhs
        */
        Vector( const Vector & rhs) : theSize{rhs.theSize},
            theCapacity{ rhs.theCapacity }, objects{nullptr}
        {
            objects = new Object[theCapacity];
            for (int k = 0; k < theSize; k++)
                objects[k] = rhs.bojects[k];
        }
        
        /**
        * @brief 重构操作符 "="，使其可以把一个Vector类传递给另一个Vector
        * 
        * @param rhs
        */
        Vector & operator=(const Vector & rhs)
        {
            Vector copy = rhs;
            std::swap( *this, copy);
            return *this;
        }

        /**
        * @brief 析构函数，清空Vector中的内存防止内存泄漏
        * 
        */
        ~Vector()
        {
            delete [] objects;
        }

        /**
        * @brief 构造函数，同时拷贝一个现有的成员生成一个Vector，同时把被拷贝的函数清空
        * 
        * @param rhs
        */
        Vector( Vector && rhs ): theSize{ rhs.theSzie },
            theCapacity{ rhs.theCapacity }, objects{ rhs.objects }
        {
            rhs.objects = nullptr;
            rhs.theSize = 0;
            rhs.theCapacity = 0;
        }

        /**
        * @brief 重构操作符 "="，通过逐步交换使其可以把一个Vector类传递给另一个Vector
        * 
        * @param rhs
        */
        Vector & operator= (Vector && rhs)
        {
            std::swap( theSize, rhs.theSize );
            std::swap( theCapacity, rhs.theCapacity );
            std::swap( objects, rhs.objects );

            return *this;
        }

        /**
        * @brief 修改Vector的大小
        * 
        * @param newSize
        */
        void resize( int newSize )
        {
            if( newSize > theCapacity )
                reserve( newSize * 2 );
            theSize = newSize;
        }

        /**
        * @brief 对Vector中的内存空间进行扩大
        * 
        * @param newCapacity
        */
        void reserve( int newCapacity )
        {
            if( newCapacity < theSize )
                return;

            Object* newArray = new Object[ newCapacity ];
            for (int k = 0; k < theSize; k++)
                newArray[k] = std::move( objects[k] );

            theCapacity = newCapacity;
            std::swap( objects, newArray);
            delete [] newArray;
        }

        /**
        * @brief 用于清空初始化指定的Vector
        * 
        */
        void clearVector()
        {
            if (objects == nullptr)
                return;
            theSize = 0;
            theCapacity = 0;
            delete [] objects;
            objects = nullptr;
        }

        /**
        * @brief 重构操作符 "[]"，使其可以直接读取Vector中对应位置的元素
        * 
        * @param rhs
        */
        Object & operator [] (int index)
            { return objects[ index ];}
        const Object & operator [] (int index) const
            { return objects[ index ];}

        /**
        * @brief 判断Vecot是否为空
        * 
        */
        bool empty() const
            { return size() == 0;}
        
        /**
        * @brief 读取Vector的大小
        * 
        */
        int size() const
            { return theSize; }

        /**
        * @brief 读取Vecot的内存空间的大小
        * 
        */
        int capacity() const
            { return theCapacity; }

        /**
        * @brief 在Vector最后增添一个元素x，当Vector空间填满时还需要对内存空间进行扩充
        * 
        * @param x
        */
        void push_back( const Object & x )
        {
            if( theSize == theCapacity )
                reserve( 2 * theCapacity + 1);
            objects[ theSize++ ] = x;
        }

        void push_back( Object && x)
        {
            if( theSize == theCapacity )
                reserve( 2 * theCapacity + 1 );
            objects[ theSize++ ] = std::move( x );
        }

        /**
        * @brief 删除Vector的最后一个元素
        * 
        */
        void pop_back()
        {
            --theSize;
        }

        /**
        * @brief 重新创造一个对应的接口
        * 
        */
        typedef Object * iterator;
        typedef const Object * const_iterator;

        /**
        * @brief 返回Vector中第一个元素位置
        * 
        */
        iterator begin()
            { return &objects[ 0 ]; }
        const_iterator begin() const
            { return &objects[ 0 ]; }

        /**
        * @brief 返回Vector的最后一个元素位置
        * 
        */
        iterator end()
            { return &objects[ size() ]; }
        const_iterator end() const
            { return &objects[ size() ]; }

};

#else
///Do nothing
#endif
